Usenet 1993 July/InfoMagic USENET CD-ROM July 1993.ISO/sources/misc/volume13/make1.6/part02

Text File | 1990-06-02 | 49.6 KB | 2,273 lines

Newsgroups: comp.sources.misc
subject: v13i019: PD make V1.6 (Part 2 of 2)
From: [e-mail] (Greg Yachuk)
Sender: [e-mail] (Brandon S. Allbery - comp.sources.misc)

Posting-number: Volume 13, Issue 19
Submitted-by: [e-mail] (Greg Yachuk)
Archive-name: make1.6/part02

#! /bin/sh
# This is a shell archive.  Remove anything before this line, then feed it
# into a shell via "sh file" or similar.  To overwrite existing files,
# type "sh file -c".
# The tool that generated this appeared in the comp.sources.unix newsgroup;
# send mail to [e-mail] if you want that tool.
# If this archive is complete, you will see the following message at the end:
#        "End of archive 2 (of 2)."
# Contents:  build.c default.mk default.msc make.h makefile
#   makefile.msc parse.c tstring.c tstring.h
# Wrapped by greggy@etude on Thu May 31 10:55:31 1990
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f 'build.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'build.c'\"
else
echo shar: Extracting \"'build.c'\" \(7577 characters\)
sed "s/^X//" >'build.c' <<'END_OF_FILE'
X/*
X * build.c    An imitation of the Unix MAKE facility
X *
X * 88-10-01 v1.0    created by greg yachuk, placed in the public domain
X * 88-10-06 v1.1    changed prerequisite list handling
X * 88-11-11 v1.2    fixed some bugs and added environment variables
X * 89-07-12 v1.3    stop appending shell commands, and flush output
X * 89-08-01 v1.4 AB    lots of new options and code
X * 89-10-30 v1.5    -f -S -q options, took some changes from v1.4
X * 90-04-18 v1.6    -b -- -W options, emulate <<, non-BSD cleanup
X */
X
X#include <stdio.h>
X#include <string.h>
X#ifdef    MSDOS
X#include <stdlib.h>
X#include <process.h>
X#endif
X#ifdef    BSD
X#include <sys/wait.h>
X#endif
X
X#include "make.h"
X#include "tstring.h"
X#include "decl.h"
X
X#ifndef    MSDOS
Xchar  **bsearch();
X#endif
X
Xchar   *tmpfn = NULL;
X#define    shellunlink()    if(tmpfn!=NULL)unlink(tmpfn),tfree(tmpfn),tmpfn=NULL
X
X/*
X * shell_cmpr    - comparison routine for "shell command" binary search.
X */
Xshell_cmpr(key, list)
Xchar   *key;
Xchar  **list;
X{
X    return (strcmp(key, *list));
X}
X
X/*
X * build    - process the shell commands
X */
Xbuild(shellp)
Xshellptr *shellp;
X{
X    char  **argv;        /* argified version of scmd */
X    int     runst;        /* exec return status */
X    char   *scmd;        /* command with symbols broken out */
X    char   *tcmd;        /* copy of scmd for `tokenize' */
X    char   *errnum;        /* error number in ascii */
X    char   *errmsg;        /* error message */
X    int     i;
X    char   *sp;
X    char   *tp;
X    char  **shcp;        /* pointer to shell command list */
X
X    if (shellp == NULL || opts.query)
X        return (0);
X
X    /* process every shell line */
X
X    for (; *shellp != NULL;
X         tfree(scmd), tfree(tcmd), tfree(argv), ++shellp)
X    {
X        /* breakout runtime symbols (e.g. $* $@ $<) */
X        scmd = breakout((*shellp)->scmd);
X
X        /* make a copy because tokenize litters '\0's */
X        tcmd = tstrcpy(scmd);
X        argv = tokenize(tcmd);
X
X        for (tp = scmd, i = 0; argv[i]; i++)
X        {
X            /* pretend to handle inline input ("<<" operator) */
X            while ((sp = strchr(argv[i], '<')) != NULL)
X            {
X                if (*++sp != '<')
X                    continue;
X
X                sp[-1] = '\0';
X
X                /* got "<<".  collect commands into a file */
X                if (*++sp != '\0')    /* got "<<TAG" */
X                    sp = shellinput(&shellp, sp);
X                else
X                {
X                    /* got "<< TAG" (note space before TAG) */
X                    sp = shellinput(&shellp, argv[i + 1]);
X                    if (argv[i + 1])
X                    {
X                        tfree(argv[i + 1]);
X                        argv[i + 1] = tstrcpy("");
X                    }
X                }
X
X                /* add the filename to the argument */
X                sp = tstrcat(argv[i], sp);
X                tfree(argv[i]);
X                argv[i] = sp;
X            }
X
X            /* now strip the quotes from the argument */
X            strcpy(tp, tunquote(argv[i]));
X            while (*tp++);
X            tp[-1] = ' ';
X        }
X
X        /* finally, terminate the command line (scmd) */
X        tp[-1] = '\0';
X
X        if (!opts.silent && (opts.noexec || !(*shellp)->s_silent))
X        {
X            puts(scmd);
X            fflush(stdout);
X        }
X
X        /* look for $(MAKE) */
X        if (equal(argv[0], opts.make))
X        {
X            /* call ourselves recursively */
X            new_make(argv);
X            continue;
X        }
X
X        if (opts.noexec)
X            continue;
X
X        /* any SHELL meta-characters MUST be handled by the shell */
X        if (!(*shellp)->s_shell && strpbrk(scmd, SHELL_METAS))
X            (*shellp)->s_shell = 1;
X
X        if (shell_cmds && !(*shellp)->s_shell)
X        {
X            /* check for COMMAND.COM builtin commands */
X            for (shcp = shell_cmds; *shcp; ++shcp);
X            shcp = bsearch(argv[0], shell_cmds,
X                       shcp - shell_cmds - 1,
X                       sizeof(char *), shell_cmpr);
X            (*shellp)->s_shell = (shcp != NULL);
X        }
X
X        /* run without COMMAND.COM if possible, 'cause it uses RAM */
X        if (!(*shellp)->s_shell)
X            runst = spawnvp(P_WAIT, argv[0], argv);
X        else
X            runst = system(scmd);
X
X        shellunlink();
X
X        if (runst == 0)
X            continue;
X
X        /* uh-oh, an error */
X        if (runst == -1)
X            perror("make");
X
X        errnum = talloc(18);
X#ifdef    MSDOS
X        errnum = itoa(runst, errnum, 10);
X#else
X        sprintf(errnum, "%d", runst);
X#endif
X        errmsg = (opts.keepon) ? "\007*** Ignoring Error code "
X            : "\007*** Error code ";
X        errmsg = tstrcat(errmsg, errnum);
X        terror(0, errmsg);
X        tfree(errmsg);
X        tfree(errnum);
X
X        if (opts.keepon)
X            return (1);
X
X        if (!opts.ignore && !(*shellp)->s_ignore)
X            exit(1);
X    }
X
X    return (0);
X}
X
X
X/*
X * shellinput    - write the list of commands into a temp file, and return name
X */
Xchar   *shellinput(shellp, eof)
Xshellptr **shellp;
Xchar   *eof;
X{
X    int     eoflen;
X    char   *scmd;
X    FILE   *tfp;
X
X    /* get rid of obvious errors */
X    if (shellp == NULL || *shellp == NULL)
X        return (NULL);
X
X    eoflen = (eof) ? strlen(eof) : 0;
X
X    /* find the name of a candidate temporary file */
X    tmpfn = tempnam(NULL, "mk");
X
X    /* write contents to stdout when '-n' is specified */
X    if (opts.noexec && !opts.silent && !(**shellp)->s_silent)
X        tfp = stdout;
X    else
X        tfp = fopen(tmpfn, "w");
X
X    while (*++*shellp)
X    {
X        /* break out the current shell command */
X        scmd = breakout((**shellp)->scmd);
X
X        /* propogate the shell command attributes */
X        (**shellp)->s_silent = ((*shellp)[-1])->s_silent;
X        (**shellp)->s_ignore = ((*shellp)[-1])->s_ignore;
X        (**shellp)->s_shell = ((*shellp)[-1])->s_shell;
X
X        /* see if we've reached the eof-word */
X        if (eof && !strncmp(scmd, eof, eoflen))
X            break;
X
X        /* no there, so write out the command to the temp file */
X        if (tfp)
X        {
X            fputs(scmd, tfp);
X            fputc('\n', tfp);
X        }
X
X        /* free the string allocated by breakout() */
X        tfree(scmd);
X    }
X
X    if (tfp != stdout)
X        fclose(tfp);
X
X    if (**shellp == NULL)
X        --* shellp;    /* point at last shell command */
X    else
X        tfree(scmd);    /* free EOF-word */
X
X    return (tmpfn);
X}
X
X
X/*
X * new_make    - save current environment
X *        - call make() recursively (actually main())
X *        - clean up new environment
X *        - restore environment
X */
Xnew_make(argv)
Xchar  **argv;
X{
X    targptr thead, tnext, tsuffix;
X    fileptr fhead, fnext;
X    symptr  shead, snext;
X    shellptr shhead, shnext;
X    char  **shcmds;
X    char  **ttlist;
X    long    tnow;
X    optnode topts;
X    int     i;
X
X    /* save all the globals */
X    tsuffix = suffix_targ;
X    thead = target_list;
X    fhead = file_list;
X    shead = symbol_list;
X    shhead = shell_list;
X    shcmds = shell_cmds;
X    ttlist = tlist;
X    tnow = now;
X    topts = opts;
X
X    /* count the arguments */
X    for (i = 0; argv[i]; ++i)
X        tunquote(argv[i]);
X
X    /* call ourselves recursively; this inherits flags */
X    ++make_level;
X    main(i, argv);
X    --make_level;
X
X    /* we're back, so gotta clean up and dispose of a few things */
X    while (target_list)
X    {
X        tnext = target_list->tnext;
X        if (target_list->tpreq)
X            tfree(target_list->tpreq);
X        if (target_list->tshell)
X            tfree(target_list->tshell);
X        tfree(target_list);
X        target_list = tnext;
X    }
X
X    while (file_list)
X    {
X        fnext = file_list->fnext;
X        tfree(file_list->fname);
X        tfree(file_list);
X        file_list = fnext;
X    }
X
X    /* don't drop all symbols, just the new ones */
X
X    while (symbol_list != shead)
X    {
X        snext = symbol_list->snext;
X        tfree(symbol_list->sname);
X        tfree(symbol_list->svalue);
X        tfree(symbol_list);
X        symbol_list = snext;
X    }
X
X    while (shell_list)
X    {
X        shnext = shell_list->slink;
X        tfree(shell_list->scmd);
X        tfree(shell_list);
X        shell_list = shnext;
X    }
X
X    /* restore our original globals */
X    suffix_targ = tsuffix;
X    target_list = thead;
X    file_list = fhead;
X    symbol_list = shead;
X    shell_list = shhead;
X    shell_cmds = shcmds;
X    tlist = ttlist;
X    now = tnow;
X    opts = topts;
X}
X
X
X#ifndef    MSDOS
Xint     spawnvp(mode, path, args)
Xint     mode;
Xchar   *path;
Xchar  **args;
X{
X    int     pid = 0;
X    int     retpid;
X#ifdef    BSD
X    union wait waitword;
X#else
X    int     waitword;
X#endif
X
X    if (mode != P_OVERLAY)
X        pid = fork();
X
X    if (pid == 0)
X        execvp(path, args);
X
X    while (((retpid = wait(&waitword)) != pid) && (retpid > 0))
X        ;
X#ifdef    BSD
X    return ((retpid == pid) ? waitword.w_retcode : (-1));
X#else
X    return ((retpid == pid) ? ((waitword >> 8) & 0x00ff) : (-1));
X#endif
X}
X#endif
END_OF_FILE
if test 7577 -ne `wc -c <'build.c'`; then
    echo shar: \"'build.c'\" unpacked with wrong size!
fi
# end of 'build.c'
fi
if test -f 'default.mk' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'default.mk'\"
else
echo shar: Extracting \"'default.mk'\" \(2487 characters\)
sed "s/^X//" >'default.mk' <<'END_OF_FILE'
X### this is the default makefile for Unix: default.mk
X
XSUFFIXES = .o .C .cxx .ec .c .y .l .s .sh
X.SUFFIXES: $(SUFFIXES)
X
X#    ASM section
XAS     = as
XASFLAGS     =
XCOMPILE.s= $(AS) $(ASFLAGS)
X.s:
X    $(AS) $(ASFLAGS) $<
X.s.o:
X    $(AS) $(ASFLAGS) -o $@ $<
X
X#    C section
XCC     = cc
XCFLAGS     = -O
XCDEBUG     = -g
XCOMPILE.c= $(CC) $(CFLAGS) -c
X.c:
X    $(LINK.c) -o $@ $< $(LDFLAGS)
X
X.c.o:
X    $(COMPILE.c) $<
X
X.c.i:
X    $(COMPILE.c) -P $<
X
X#    CPP Section
XCPP     = CC
XCPPFLAGS = -O
XCPPDEBUG = -g
XCOMPILE.cpp = $(CPP) $(CPPFLAGS)
X.C .cxx:
X    $(CPP) $(CPPFLAGS) -o $@ $< $(LDFLAGS)
X
X.C.o .cxx.o:
X    $(COMPILE.cpp) $<
X
X.C.c .cxx.c:
X    $(COMPILE.cpp) -P $<
X
X#    ESQL/C section
XESQL     = esql
XEFLAGS     =
XCOMPILE.e= $(ESQL) $(EFLAGS)
X.ec:
X    $(COMPILE.e) -e $<
X    $(LINK.c) -o $@ $*.c $(LDFLAGS)
X
X.ec.o:
X    $(COMPILE.e) -e $<
X    $(COMPILE.c) $*.c
X
X.ec.c:
X    $(COMPILE.e) -e $<
X
X#    Lex section
XLEX     = lex
XLFLAGS     =
XLEX.l     = $(LEX) $(LFLAGS) -t
X.l:
X    $(LEX.l) $< > $*.c
X    $(LINK.c) -o $@ $*.c $(LDFLAGS) -ll
X
X.l.o:
X    $(LEX.l) $< > $*.c
X    $(COMPILE.c) $*.c
X
X.l.c:
X    $(LEX.l) $< > $*.c
X
X#    YACC section
XYACC     = yacc
XYFLAGS     =
XYACC.y     = $(YACC) $(YFLAGS)
X.y:
X    $(YACC.y) $<
X    $(LINK.c) -o $@ y.tab.c $(LDFLAGS) -ly
X    $(RM) y.tab.c
X
X.y.o:
X    $(YACC.y) $<
X    $(COMPILE.c) -o $*.o y.tab.c
X    $(RM) y.tab.c
X
X.y.c:
X    $(YACC) $(YFLAGS) $<
X    $(MV) y.tab.c $@
X
X.y.h:
X    $(YACC) $(YFLAGS) -d $<
X    $(RM) y.tab.c
X    $(MV) y.tab.h $@
X
X#    Shell script section
X.sh:
X    cp $< $@
X
X#    BSD Unix Misc section
XA        = .a
XAR       = ar
XARFLAGS  =
XBIN      = /usr/local/bin
XCP       = cp
XE        =
XEDITOR   = /usr/bin/vi
XGFLAGS   =
XGET      = get
XLDEBUG   =
XLDFLAGS  =
XLD       = ld
XLIBDIR   =
XLINK.c   = $(CC) $(CFLAGS)
XMAKE     = make
XMKDEPEND = makedepend
XMODEL    =
XMV       = mv
XO        = .o
XRANLIB   = ranlib
XRM       = rm -f
XSHELL    = /bin/csh
XSHELLCMD =
XSTACK    =
X
X#    DOS Misc section
X#A        = .lib
X#AR       = lib
X#ARFLAGS  =
X#BIN      = C:\bin
X#CP       = cp
X#E        = .exe
X#EDITOR   = $(BIN)\vi
X#GFLAGS   =
X#GET      = echo cannot get
X#LDEBUG   = /link /noe /noi /co /st:$(STACK) $(LIBS)
X#LDFLAGS  = /link /noe /noi /st:$(STACK) $(LIBS)
X#LD       = $(CC) $(CFLAGS)
X#LIBDIR   = c:\msc5.1\lib
X#LINK.c   = $(CC) $(CFLAGS)
X#MAKE     = make
X#MKDEPEND = mkdepend
X#MODEL    = S
X#MV       = mv
X#O        = .o
X#RANLIB   = echo cannot ranlib
X#RM       = rm -f
X#SHELL    = command /c
X#SHELLCMD = break call cd chcp chdir cls copy ctty date del dir \
X#       echo erase exit for goto if md mkdir path pause prompt \
X#       rd rem ren rename rmdir set shift time type ver verify vol
X#STACK    = 2000
END_OF_FILE
if test 2487 -ne `wc -c <'default.mk'`; then
    echo shar: \"'default.mk'\" unpacked with wrong size!
fi
# end of 'default.mk'
fi
if test -f 'default.msc' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'default.msc'\"
else
echo shar: Extracting \"'default.msc'\" \(3930 characters\)
sed "s/^X//" >'default.msc' <<'END_OF_FILE'
X### this is the default makefile for DOS: default.mk
X
XSUFFIXES = .cpp .c .asm .l .y .ec
X.SUFFIXES: $(SUFFIXES)
X
X#    ASM section
XAS     = masm
XASFLAGS     = /mx            # don't convert to upper case
XCOMPILE.s= $(AS) $(ASFLAGS)
X.asm .asm.com:
X     $(COMPILE.s) $<;
X     $(LINK.c) -o $*.exe $*.obj $(LDFLAGS)
X     $(RM) $*.obj
X     exe2bin $*.exe $*.com
X     $(RM) $*.exe
Xasm.exe:
X     $(COMPILE.s) $<;
X     $(LINK.c) -o $@ $*.obj $(LDFLAGS)
X     $(RM) $*.obj
X.asm.obj:
X     $(COMPILE.s) $<;
X.asm.o:
X     $(COMPILE.s) $<;
X     mv $*.obj $@
X
X#    C section
XCC     = cl -A$(MODEL)
XCFLAGS     = /Ox /G2        # full optimization, 80286 opcodes
XCDEBUG     = /Od /Zi        # no optimization, Codeview debuggable
XCOMPILE.c= $(CC) $(CFLAGS) -c
X.c.com:
X     $(COMPILE.cpp) -mt $< $(LIBS)
X     $(RM) $*.obj
X.c .c.exe:
X     $(LINK.c) -o $@ $< $(LDFLAGS)
X     $(RM) $*.obj
X.c.o:
X     $(COMPILE.c) /Fo$*.o $<
X.c.obj:
X     $(COMPILE.c) $<
X
X#    D section (ANSI C declaration headers)
X.c.d:
X     echo "#ifndef NOPROTOTYPES" > $*.tmp
X    -$(COMPILE.c) -DNOPROTOTYPES -Zg $< >> $*.tmp
X     echo "#endif" >> $*.tmp
X    +updexhdr $*.tmp $*.d
X     $(RM) $*.tmp
X
X#    I section (preprocessed C files)
X.c.i:
X     $(COMPILE.c) -P $<
X
X#    CPP Section
XCPPINCDIR= c:\zortech\include
XCPP     = ztc -DNO_EXT_KEYS -I$(CPPINCDIR) -B -m$(MODEL)i    # integer only
XCPPF     = ztc -DNO_EXT_KEYS -I$(CPPINCDIR) -B -m$(MODEL)    # floats also
XCPPFLAGS = -o                    # full optimization
XCPPDEBUG = -g -co -s                # codeview and stack checking
XCOMPILE.cpp=$(CPP) $(CPPFLAGS)
X.cpp .cpp.com:
X     $(COMPILE.cpp) -mt $<
X     $(RM) $*.obj
X.cpp.exe:
X     $(COMPILE.cpp) $<
X     $(RM) $*.obj
X.cpp.obj:
X     $(COMPILE.cpp) -c $<
X.cpp.o:
X     $(COMPILE.cpp) -c $<
X     $(MV) $*.obj $@
X.cpp.c:
X    $(COMPILE.cpp) -c -e -l$*.c $<
X
X#    ESQL/C section
XESQL     = esql
XEFLAGS     =
XCOMPILE.e= $(ESQL) $(EFLAGS)
X.ec .ec.exe:
X     $(COMPILE.e) -e $<
X     $(LINK.c) -o $@ $*.c $(LDFLAGS) $(MODEL)libsql
X     $(RM) $*.obj $*.c
X.ec.o:
X     $(COMPILE.e) -e $<
X     $(COMPILE.c) /Fo$*.o $*.c
X     $(RM) $*.c
X.ec.obj:
X     $(COMPILE.e) -e $<
X     $(COMPILE.c) $*.c
X     $(RM) $*.c
X.ec.c:
X     $(COMPILE.e) -e $<
X
X#    Lex section
XLEX     = flex
XLFLAGS     = -I                # interactive scanner
XLEX.l     = $(LEX) $(LFLAGS) -t
X.l.com:
X     $(LEX.l) $< > $*.c
X     $(COMPILE.cpp) -mt $*.c
X     $(RM) $*.obj $*.c
X.l .l.exe:
X     $(LEX.l) $< > $*.c
X     $(LINK.c) -o $@ $*.c $(LDFLAGS)
X     $(RM) $*.obj $*.c
X.l.o:
X     $(LEX.l) $< > $*.c
X     $(COMPILE.c) /Fo$*.o $*.c
X     $(RM) $*.c
X.l.obj:
X     $(LEX.l) $< > $*.c
X     $(COMPILE.c) $*.c
X     $(RM) $*.c
X.l.c:
X     $(LEX.l) $< > $@
X
X#    YACC Section
XYACC     = yacc
XYFLAGS     =
XYACC.y     = $(YACC) $(YFLAGS)
X.y.com:
X     $(YACC.y) $<
X     $(COMPILE.cpp) -mt ytab.c
X     $(RM) $*.obj ytab.c
X.y .y.exe:
X     $(YACC.y) $<
X     $(LINK.c) -o $@ ytab.c $(LDFLAGS)
X     $(RM) $*.obj ytab.c
X.y.o:
X     $(YACC.y) $<
X     $(COMPILE.c) /Fo$*.o ytab.c
X     $(RM) ytab.c
X.y.obj:
X     $(YACC.y) $<
X     $(COMPILE.c) ytab.c
X     $(RM) ytab.c
X.y.h:
X     $(YACC.y) -d $<
X     $(RM) ytab.c
X     $(MV) ytab.h $@
X.y.c:
X     $(YACC.y) $<
X     $(MV) ytab.c $@
X
X#    BSD Unix Misc section
X#A        = .a
X#AR       = ar
X#ARFLAGS  =
X#BIN      = /usr/local/bin
X#CP       = cp
X#E        =
X#EDITOR   = /usr/bin/vi
X#GFLAGS   =
X#GET      = get
X#LDEBUG   =
X#LDFLAGS  =
X#LD       = ld
X#LIBDIR   =
X#LINK.c   = $(CC) $(CFLAGS)
X#MAKE     = make
X#MKDEPEND = makedepend
X#MODEL    =
X#MV       = mv
X#O        = .o
X#RANLIB   = ranlib
X#RM       = rm -f
X#SHELL    = /bin/csh
X#SHELLCMD =
X#STACK    =
X
X#    DOS Misc section
XA        = .lib
XAR       = lib
XARFLAGS  =
XBIN      = C:\bin
XCP       = cp
XE        = .exe
XEDITOR   = $(BIN)\vi
XGFLAGS   =
XGET      = echo cannot get
XLDEBUG   = /link /noe /noi /co /st:$(STACK) $(LIBS)
XLDFLAGS  = /link /noe /noi /st:$(STACK) $(LIBS)
XLD       = $(CC) $(CFLAGS)
XLIBDIR   = c:\msc5.1\lib
XLINK.c   = $(CC) $(CFLAGS)
XMAKE     = make
XMKDEPEND = mkdepend
XMODEL    = S
XMV       = mv
XO        = .o
XRANLIB   = echo cannot ranlib
XRM       = rm -f
XSHELL    = command /c
XSHELLCMD = break call cd chcp chdir cls copy ctty date del dir \
X       echo erase exit for goto if md mkdir path pause prompt \
X       rd rem ren rename rmdir set shift time type ver verify vol
XSTACK    = 2000
END_OF_FILE
if test 3930 -ne `wc -c <'default.msc'`; then
    echo shar: \"'default.msc'\" unpacked with wrong size!
fi
# end of 'default.msc'
fi
if test -f 'make.h' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'make.h'\"
else
echo shar: Extracting \"'make.h'\" \(3424 characters\)
sed "s/^X//" >'make.h' <<'END_OF_FILE'
X/*
X * make.h
X *
X * 88-10-01 v1.0    created by greg yachuk, placed in the public domain
X * 88-10-06 v1.1    changed prerequisite list handling
X * 88-11-11 v1.2    fixed some bugs and added environment variables
X * 89-07-12 v1.3    stop appending shell commands, and flush output
X * 89-08-01 v1.4 AB    lots of new options and code
X * 89-10-30 v1.5    -f -S -q options, took some changes from v1.4
X * 90-04-18 v1.6    -b -- -W options, emulate <<, non-BSD cleanup
X */
X
X#define MAKEINI "default.mk"
X
X#ifdef    MSDOS
X#define    PATH_SEPARATOR    ";"
X#define    FILE_SEPARATOR    ":/\\"
X#define    SHELL_METAS    "<|>"
X#else
X#define    PATH_SEPARATOR    ":"
X#define    FILE_SEPARATOR    "/"
X#define    SHELL_METAS    "<|>`*?()[];&$"
X#endif
X
X#define    MAXNEGTIME    0x80000000
X
X#define    equal(s,t)        (!strcmp((s),(t)))
X#define    get_target(t)        hash_target((t), NULL)
X#define    get_file(f)        hash_file((f), NULL)
X#define    append_preq(t,p)    (fileptr*)append_node((char**)(t),(char**)(p),sizeof(fileptr*))
X#define    append_shell(t,s)    (shellptr*)append_node((char**)(t),(char**)(s),sizeof(shellptr*))
X
Xtypedef unsigned short t_mask;
X
Xtypedef struct targnode
X{
X    t_mask  tmask;        /* mask to avoid string compares */
X    struct targnode *tnext;    /* next target in global target list */
X    struct filenode *tfile;    /* file node for this target */
X    struct filenode **tpreq;/* pre-req list for this target */
X    struct shellnode **tshell;    /* command list for this target */
X}       targnode, *targptr;
X
Xtypedef struct filenode
X{
X    t_mask  fmask;        /* mask to avoid string compares */
X    char   *fname;        /* name of this file (targ, preq...) */
X    long    ftime;        /* last MODIFY time for this file */
X    struct filenode *fnext;    /* next file node in global file list */
X}       filenode, *fileptr;
X
Xtypedef struct shellnode
X{
X    char   *scmd;        /* text of command */
X    unsigned s_silent:1;    /* don't echo before executing */
X    unsigned s_ignore:1;    /* ignore exit status */
X    unsigned s_shell:1;    /* force spawning of command.com */
X    struct shellnode *slink;/* next shell node in global list */
X}       shellnode, *shellptr;
X
Xtypedef struct symnode
X{
X    t_mask  smask;        /* mask to avoid string compares */
X    char   *sname;        /* name of a symbol */
X    char   *svalue;        /* value of a symbol */
X    struct symnode *snext;    /* next symbol node in global list */
X    int     scmd;        /* command line macro? */
X    int     slevel;        /* level of new_make() */
X}       symnode, *symptr;
X
Xtypedef struct optnode
X{
X    unsigned depend;    /* -d */
X    unsigned display:1;    /* -D */
X    unsigned envirn:1;    /* -e */
X    unsigned ignore:1;    /* -i */
X    unsigned keepon:1;    /* -k */
X    unsigned noexec:1;    /* -n */
X    unsigned query:1;    /* -q */
X    unsigned silent:1;    /* -s */
X    unsigned touch:1;    /* -t */
X    char   *make;        /* current value of $(MAKE) */
X}       optnode;
X
Xextern targptr target_list;    /* global list of targets */
Xextern fileptr file_list;    /* global list of file nodes */
Xextern symptr symbol_list;    /* global list of symbol nodes */
Xextern shellptr shell_list;    /* global list of shell nodes */
X
Xextern char **shell_cmds;    /* commands which force usage of SHELL */
X
Xextern int make_level;        /* level of new_make() */
X
Xextern targptr first_targ;    /* first target (if nothing named) */
Xextern targptr suffix_targ;    /* target node of ".SUFFIXES" */
X
Xextern optnode opts;        /* various options */
Xextern char **tlist;        /* list of command line targets */
Xextern long now;        /* current time */
X
X#ifndef    MSDOS
Xchar   *getenv();
X
X#define    P_WAIT        1
X#define    P_NOWAIT    2
X#define    P_OVERLAY    3
X#endif                /* MSDOS */
END_OF_FILE
if test 3424 -ne `wc -c <'make.h'`; then
    echo shar: \"'make.h'\" unpacked with wrong size!
fi
# end of 'make.h'
fi
if test -f 'makefile' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'makefile'\"
else
echo shar: Extracting \"'makefile'\" \(1286 characters\)
sed "s/^X//" >'makefile' <<'END_OF_FILE'
X# name of this program
XNAME    = make
X
X# define the FLAGS as required for MSDOS or Unix
XCFLAGS    = -O
XLDFLAGS    =
X
XSRCS    = make.c parse.c build.c tstring.c
XOBJS    = make.o parse.o build.o tstring.o
XPROG    = $(NAME)$E
X
X# define your installation directory
XBIN    = $(HOME)/bin
X
X# archive utility
XARCADD    = zoo a
X
X# files to archive
XARCS    = decl.h make.h tstring.h make.c parse.c build.c tstring.c \
X      default.mk default.bsd makefile makefile.bsd make.doc \
X      README $(PROG)
X
Xall:    $(PROG)
X
X$(PROG):    $(OBJS)
X    $(CC) $(CFLAGS) $(OBJS) -o $(PROG) $(LDFLAGS)
X
Xarc:    $(NAME).zoo
Xzoo:    $(NAME).zoo
X
X$(NAME).zoo:    $(ARCS)
X    $(RM) $(NAME).zoo
X    $(ARCADD) $(NAME).zoo $(ARCS)
X
Xinstall:    $(BIN)/$(PROG) $(BIN)/default.mk
X$(BIN)/$(PROG):    $(PROG)
X    cp $(PROG) $(BIN)/$(PROG)
X$(BIN)/default.mk: default.mk
X    cp default.mk $(BIN)/default.mk
X
Xclean:
X    -$(RM) *.o
X    -$(RM) *.bak
X
X# use this to check the size of the program (use chkdsk if necessary)
Xsize:
X    pmap
X
Xdepend:
X    $(MKDEPEND) $(SRCS) > makefile.new
X    $(MV) makefile makefile.BAK
X    $(MV) makefile.new makefile
X
Xtest:    $(OBJS)
X    link @<<END_OF_LINK
X        $(OBJS)
X        x$(NAME)
X        /cparmaxalloc:1 /noe /stack:2000
X        $(LIBS)
X    END_OF_LINK
X
X# DO NOT DELETE THIS LINE
X
Xmake.o: make.h tstring.h decl.h
Xparse.o: make.h tstring.h decl.h
Xbuild.o: make.h tstring.h decl.h
Xtstring.o: tstring.h
END_OF_FILE
if test 1286 -ne `wc -c <'makefile'`; then
    echo shar: \"'makefile'\" unpacked with wrong size!
fi
# end of 'makefile'
fi
if test -f 'makefile.msc' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'makefile.msc'\"
else
echo shar: Extracting \"'makefile.msc'\" \(1483 characters\)
sed "s/^X//" >'makefile.msc' <<'END_OF_FILE'
X# name of this program
XNAME    = make
X
X# define the FLAGS as required for MSDOS or Unix
XCFLAGS    = /Oals /Gs /G2
XLDFLAGS = /link /cparmaxalloc:1 /noe /stack:2000 $(LIBS)
X
XSRCS    = make.c parse.c build.c tstring.c
XOBJS    = make.o parse.o build.o tstring.o
XPROG    = $(NAME)$E
X
X# define your installation directory
XBIN    = c:/bin
X
X# archive utility
XARCADD    = zoo a
X
X# files to archive
XARC1    = decl.h make.h tstring.h make.c parse.c build.c tstring.c default.mk
XARC2    = default.bsd makefile makefile.bsd make.doc README $(PROG)
XARCS    = $(ARC1) $(ARC2)
X
Xall:    $(PROG)
X
X$(PROG):    $(OBJS)
X    echo out of date dependents($@): $?
X    $(CC) $(CFLAGS) $(OBJS) -o $(PROG) $(LDFLAGS)
X
Xarc:    $(NAME).zoo
Xzoo:    $(NAME).zoo
X
X$(NAME).zoo:    $(ARCS)
X    $(RM) $(NAME).zoo
X    $(ARCADD) $(NAME).zoo $(ARC1)
X    $(ARCADD) $(NAME).zoo $(ARC2)
X
Xinstall:    $(BIN)/$(PROG) $(BIN)/default.mk
X$(BIN)/$(PROG):    $(PROG)
X    cp $(PROG) $(BIN)/$(PROG)
X$(BIN)/default.mk: default.mk
X    cp default.mk $(BIN)/default.mk
X
Xclean:
X    -$(RM) *.o
X    -$(RM) *.bak
X
X# use this to check the size of the program (use chkdsk if necessary)
Xsize:
X    pmap
X
Xdepend:
X    $(MKDEPEND) $(SRCS) > makefile.new
X    $(MV) makefile makefile.BAK
X    $(MV) makefile.new makefile
X
Xtest:    $(OBJS)
X    echo out of date dependents($@): $?
X    link @<<END_OF_LINK
X        $(OBJS)
X        x$(NAME)
X        /cparmaxalloc:1 /noe /stack:2000
X        $(LIBS)
X    END_OF_LINK
X    echo End Of Link
X
X# DO NOT DELETE THIS LINE
X
Xmake.o: make.h tstring.h decl.h
Xparse.o: make.h tstring.h decl.h
Xbuild.o: make.h tstring.h decl.h
Xtstring.o: tstring.h
END_OF_FILE
if test 1483 -ne `wc -c <'makefile.msc'`; then
    echo shar: \"'makefile.msc'\" unpacked with wrong size!
fi
# end of 'makefile.msc'
fi
if test -f 'parse.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'parse.c'\"
else
echo shar: Extracting \"'parse.c'\" \(17139 characters\)
sed "s/^X//" >'parse.c' <<'END_OF_FILE'
X/*
X * parse.c
X *
X * 88-10-01 v1.0    created by greg yachuk, placed in the public domain
X * 88-10-06 v1.1    changed prerequisite list handling
X * 88-11-11 v1.2    fixed some bugs and added environment variables
X * 89-07-12 v1.3    stop appending shell commands, and flush output
X * 89-08-01 v1.4 AB    lots of new options and code
X * 89-10-30 v1.5    -f -S -q options, took some changes from v1.4
X * 90-04-18 v1.6    -b -- -W options, emulate <<, non-BSD cleanup
X */
X#include <stdio.h>
X#include <ctype.h>
X#include <string.h>
X#ifdef    MSDOS
X#include <stdlib.h>
X#endif
X
X#include "make.h"
X#include "tstring.h"
X#include "decl.h"
X
X/*
X * parse    - read (text) makefile, and parse
X *        - close file before returing
X *
X * lines have the following format:
X *    # with or without preceeding spaces/tabs    (comment line)
X *    <TAB> commands                    (shell line)
X *    name = stuff                    (macro)
X *    name += stuff                    (macro)
X *    targ [targ...] : [pre-req...] [; shell cmd ]    (target line)
X */
Xparse(fd)
XFILE   *fd;
X{
X    char   *input;
X    char   *ip;
X    char   *colonp;
X    char    schar;
X    int     ntargs, npreqs, nshell;
X    int     tmax, pmax, smax;
X    targptr *targs;
X    fileptr *preqs;
X    shellptr *shells;
X
X    if (fd == NULL)
X        return (0);
X
X    /* start off with a short list of targets */
X    targs = (targptr *) grow_list(NULL, &tmax);
X    preqs = (fileptr *) grow_list(NULL, &pmax);
X    shells = (shellptr *) grow_list(NULL, &smax);
X
X    ntargs = npreqs = nshell = 0;
X
X    /* maximize buffering */
X    setvbuf(fd, NULL, _IOFBF, 2048);
X
X    while ((input = tgets(fd)) != NULL)
X    {
X        /* punt on comments and blank lines */
X        for (ip = input; isspace(*ip); ++ip);
X        if (*ip == '#' || *ip == '\0')
X            continue;
X
X        /* process include files */
X        if (!strncmp(ip, "include", 7))
X        {
X            /* skip spaces AFTER "include" */
X            for (ip += 7; isspace(*ip); ++ip);
X
X            /* process macros in the filename */
X            ip = breakout(ip);
X
X            /* parse the makefile */
X            if (!parse(fopen(ip, "r")))
X                terror(1, tstrcat("cannot open ", ip));
X
X            /* free up the broken-out string */
X            tfree(ip);
X            continue;    /* get next input line */
X        }
X
X        /* display the makefile line ? */
X        if (opts.display)
X            puts(input);
X
X        /* get rid of comments and preceeding spaces */
X        for (colonp = ip; *colonp && *colonp != '#'; ++colonp)
X        {
X            if (*colonp == '\'' || *colonp == '"')
X                colonp = tstrspan(colonp);
X        }
X
X        for (--colonp; colonp >= ip && isspace(*colonp); --colonp);
X
X        /* we *know* that some non-space is on this line, from above */
X        if (colonp >= ip)
X            *++colonp = '\0';
X
X        /* see if we have a shell command */
X        if (isspace(*input))
X        {
X            if (ntargs == 0)
X                terror(1, "rules must be after target");
X    got_shell:
X            if (nshell == smax)
X            {
X                shells = (shellptr *)
X                    grow_list((char **) shells, &smax);
X            }
X            shells[nshell++] = add_shell(ip);
X            continue;
X        }
X
X        /* not a shell line, so must be a target or a macro */
X        if (ntargs != 0)
X        {
X            /* link previous preq's and shell's */
X            targs[ntargs] = NULL;
X            preqs[npreqs] = NULL;
X            shells[nshell] = NULL;
X            link_targs(targs, preqs, shells);
X            ntargs = npreqs = nshell = 0;
X        }
X
X        /* don't break out symbols until macro is invoked */
X        if (add_macro(ip, 0))
X            continue;
X
X        /* okay, we have a target line; break out macro symbols */
X        input = breakout(ip);
X
X        /* just look for tokens with standard isspace() separators */
X        ip = token(input, NULL, &schar);
X        while (ip)
X        {
X            colonp = strchr(ip, ':');
X#ifdef    MSDOS
X            /* need to allow c:/bin/make.exe as a target */
X            if (colonp && colonp - ip == 1)
X                colonp = strchr(colonp + 1, ':');
X#endif
X            if (colonp)
X            {
X                /* got a separator */
X                *colonp = '\0';
X
X                /* if at front of token, target is done */
X                if (colonp == ip)
X                    break;
X            }
X
X            if (ntargs == tmax)
X                targs = (targptr *) grow_list((char **) targs,
X                                  &tmax);
X            targs[ntargs] = add_target(ip);
X
X            /* make sure we don't save .INIT as our 1st target */
X            if (first_targ == NULL && *ip != '.')
X                first_targ = targs[ntargs];
X            ++ntargs;
X
X            if (colonp)
X                break;
X            ip = token(NULL, NULL, &schar);
X        }
X
X        /* a target line without a colon?  naughty, naughty! */
X        if (!colonp)
X            terror(-1, "Unexpected end of line seen");
X
X/*
X *         taking care of four possible cases:
X *            1)    object : source
X *            2)    object: source
X *            3)    object :source
X *            4)    object:source
X */
X
X        if (colonp && *++colonp)
X            ip = colonp;
X        else
X            ip = token(NULL, NULL, &schar);
X
X        /* link the pre-req's */
X        while (ip)
X        {
X            if ((colonp = strchr(ip, ';')) != NULL)
X            {
X                ip[strlen(ip)] = schar;
X                *colonp = '\0';
X            }
X
X            if (*ip)
X            {
X                if (npreqs == pmax)
X                {
X                    preqs = (fileptr *)
X                        grow_list((char **) preqs,
X                              &pmax);
X                }
X
X                preqs[npreqs++] = add_file(ip);
X            }
X
X            if (colonp)
X            {
X                ip = colonp + 1;
X                goto got_shell;
X            }
X
X            ip = token(NULL, NULL, &schar);
X        }
X
X        /* gotta free the line allocated by breakout() */
X        tfree(input);
X    }
X
X    /* link up any dangling dependants */
X    if (ntargs != 0)
X    {
X        targs[ntargs] = NULL;
X        preqs[npreqs] = NULL;
X        shells[nshell] = NULL;
X        link_targs(targs, preqs, shells);
X    }
X
X    /* clean up our mallocs */
X    tfree(targs);
X    tfree(preqs);
X    tfree(shells);
X
X    fclose(fd);
X    return (1);
X}
X
X
X/*
X * link_targs    - force a list of targs to point to same preq's and shell's
X */
Xlink_targs(targs, preqs, shells)
Xtargptr *targs;
Xfileptr *preqs;
Xshellptr *shells;
X{
X    while (targs && *targs)
X    {
X        /* process some special targets */
X        if ((*targs)->tfile->fname[0] == '.')
X        {
X            if (equal((*targs)->tfile->fname, ".SILENT"))
X                opts.silent = 1;
X            else
X            if (equal((*targs)->tfile->fname, ".IGNORE"))
X                opts.ignore = 1;
X            else
X            if (equal((*targs)->tfile->fname, ".SUFFIXES"))
X                /*
X                 * set `suffix_targ' to speed up
X                 * `default_rule'
X                 */
X                suffix_targ = *targs;
X
X            /* special rule has preq's reset */
X            /* normally, preq's are merely appended */
X            if (*preqs == NULL && (*targs)->tpreq != NULL)
X            {
X                tfree((*targs)->tpreq);
X                (*targs)->tpreq = NULL;
X            }
X
X            /* special rules have their shell commands replaced */
X            if ((*targs)->tshell != NULL && *shells != NULL)
X            {
X                shellptr *sp;
X
X                for (sp = (*targs)->tshell; *sp; ++sp)
X                    tfree(*sp);
X                tfree((*targs)->tshell);
X                (*targs)->tshell = NULL;
X            }
X        }
X
X        /* each target in the list points to the preq's and shell's */
X        (*targs)->tpreq = append_preq((*targs)->tpreq, preqs);
X
X        /* we cannot expand the list of shell commands */
X        if ((*targs)->tshell != NULL && *shells != NULL)
X        {
X            terror(1, tstrcat("Too many rules defined for target ",
X                      (*targs)->tfile->fname));
X        }
X        (*targs)->tshell = append_shell((*targs)->tshell, shells);
X        ++targs;
X    }
X}
X
X
X/* macros must have the format: WORD = more stuff
X *                     WORD= more stuff
X *                WORD =more stuff
X *                WORD=more stuff
X *            or:    WORD += more stuff
X *                WORD +=more stuff
X *
X * it is assumed that there is no leading whitespace in `input'
X */
Xadd_macro(input, scmd)
Xchar   *input;
Xint     scmd;
X{
X    char   *eqsign;
X    char   *value;
X    symptr  symp;
X
X    /* gotta have an '=' to be a macro */
X    eqsign = strchr(input, '=');
X    if (eqsign == NULL)
X        return (0);
X
X    /* make sure we catch imbedded '='s (e.g. MACRO=STUFF) */
X    for (value = input; *value && !isspace(*value); ++value);
X    if (value > eqsign)
X        value = eqsign;
X
X    /* terminate the macro name */
X    *value = '\0';
X
X    /* find start of value */
X    for (value = eqsign + 1; isspace(*value); ++value);
X
X    /* look for concat character */
X    --eqsign;
X
X    if (eqsign < input || (eqsign == input && *eqsign == '+'))
X        terror(1, "Badly formed macro");
X
X    if (*eqsign == '+')
X    {
X        /* append to the current macro definition */
X        *eqsign = '\0';
X        symp = get_symbol(input, scmd);
X        if (symp->scmd && !scmd)
X            return (1);
X        if (symp->slevel < make_level)
X            symp = dup_symbol(symp, symp->svalue);
X        if (symp->svalue)
X        {
X            eqsign = tstrcat(symp->svalue, " ");
X            value = tstrcat(eqsign, value);
X            tfree(eqsign);
X            tfree(symp->svalue);
X            symp->svalue = value;
X            return (1);
X        }
X    }
X
X    add_symbol(input, value, scmd);
X    return (1);
X}
X
X
X/*
X * add_symbol    - add a <name,value> pair to the symbol table
X *        - override existing symbol value
X *        - mark as either command-line macro or not
X */
Xadd_symbol(name, value, scmd)
Xchar   *name;
Xchar   *value;
Xint     scmd;
X{
X    symptr  symp;
X
X    symp = get_symbol(name, scmd);
X    if (symp->scmd & !scmd)
X        return;
X    if (symp->slevel < make_level)
X        symp = dup_symbol(symp, NULL);    /* don't dup the value */
X    if (symp->svalue)
X        tfree(symp->svalue);
X    symp->svalue = tstrcpy(value);
X    symp->scmd = scmd;
X}
X
X
X/*
X * get_symbol    - find a symbol in the symbol table
X *        - if non-extant, create <name,NULL>
X *        - return created or found symbol node
X */
Xsymptr  get_symbol(name, scmd)
Xchar   *name;
Xint     scmd;
X{
X    symptr  symp;
X    t_mask  mask;
X    char   *np;
X
X    /* use `mask' to screen out most string comparisons */
X    mask = 0;
X    np = name;
X    while (*np)
X        mask += *np++;
X
X    /* linear search through symbol list */
X    for (symp = symbol_list; symp != NULL; symp = symp->snext)
X    {
X        if (mask != symp->smask)
X            continue;
X
X        if (equal(name, symp->sname))
X            return (symp);
X    }
X
X    symp = tnew(symnode);    /* allocate symbol node */
X    symp->smask = mask;    /* record mask for later */
X    symp->sname = tstrcpy(name);    /* allocate string and copy name */
X    symp->scmd = scmd;    /* command line macro? */
X    symp->slevel = make_level;    /* current new_make() level */
X
X    /* get the value from the environment, if it is there */
X
X    if ((symp->svalue = getenv(name)) != NULL)
X    {
X        symp->svalue = tstrcpy(symp->svalue);
X
X        /*
X         * if `-e', let command line macros override, but not macro
X         * assignments in the makefile.
X         */
X        if (opts.envirn)
X            symp->scmd = 1;
X    }
X
X    symp->snext = symbol_list;    /* link to head of symbol list */
X    symbol_list = symp;
X
X    return (symp);
X}
X
X
X/*
X * dup_sym    - duplicate a symbol node, but at current new_make() level
X */
Xsymptr  dup_symbol(symp, value)
Xsymptr  symp;
Xchar   *value;
X{
X    symptr  nsp;
X
X    nsp = tnew(symnode);    /* allocate symbol node */
X    nsp->smask = symp->smask;    /* record mask for later */
X    nsp->sname = tstrcpy(symp->sname);    /* allocate string and copy
X                         * name */
X    nsp->svalue = (value == NULL) ? NULL : tstrcpy(value);
X    nsp->scmd = symp->scmd;    /* command line macro? */
X    nsp->slevel = make_level;    /* current new_make() level */
X
X    nsp->snext = symbol_list;    /* link to head of symbol list */
X    symbol_list = nsp;
X
X    return (nsp);
X}
X
X
X/*
X * add_target    - return extant target node, or create new one
X */
Xtargptr add_target(name)
Xchar   *name;
X{
X    t_mask  mask;
X    targptr targp;
X    fileptr filep;
X
X    /* each target must have a file node */
X    filep = add_file(name);
X
X    /* see if target already exists */
X    targp = hash_target(name, &mask);
X    if (targp)
X        return (targp);
X
X    /* oh well, gotta create one */
X    targp = tnew(targnode);    /* allocate a target node */
X    targp->tmask = mask;    /* save mask for later */
X    targp->tfile = filep;    /* save pointer to file node */
X    targp->tpreq = NULL;    /* no pre-req's yet */
X    targp->tshell = NULL;    /* no shell lines yet */
X
X    targp->tnext = target_list;    /* link to front of target list */
X    target_list = targp;
X
X    return (targp);
X}
X
X
X/*
X * hash_target    - look up target (by name) in target list
X *        - return target node or NULL
X *        - if requested, also return the mask
X */
Xtargptr hash_target(name, maskp)
Xchar   *name;
Xt_mask *maskp;
X{
X    targptr targp;
X    t_mask  mask;
X    char   *np;
X
X    /* use `mask' to screen out most string comparisons */
X    mask = 0;
X    np = name;
X    while (*np)
X        mask += *np++;
X
X    /* see if we gotta return it */
X    if (maskp != NULL)
X        *maskp = mask;
X
X    /* linear search through target list */
X    for (targp = target_list; targp != NULL; targp = targp->tnext)
X    {
X        if (mask != targp->tmask)
X            continue;
X
X        /* target name is ONLY stored in the file node */
X        if (equal(name, targp->tfile->fname))
X            return (targp);
X    }
X
X    /* nope, no target here */
X    return (NULL);
X}
X
X
X/*
X * add_file    - return a found or created file node
X */
Xfileptr add_file(name)
Xchar   *name;
X{
X    t_mask  mask;
X    fileptr filep;
X
X    /* see if file node already exists */
X    filep = hash_file(name, &mask);
X    if (filep)
X        return (filep);
X
X    filep = tnew(filenode);    /* allocate new file node */
X    filep->fmask = mask;    /* save mask for later */
X    filep->fname = tstrcpy(name);    /* allocate string and copy name */
X    filep->ftime = MAXNEGTIME;    /* init MODIFY time to long time ago */
X
X    filep->fnext = file_list;    /* link to head of file list */
X    file_list = filep;
X
X    return (filep);
X}
X
X
X/*
X * hash_file    - look up file (by name) in file list
X *        - return file node or NULL
X *        - if requested, also return the mask
X */
Xfileptr hash_file(name, maskp)
Xchar   *name;
Xt_mask *maskp;
X{
X    fileptr filep;
X    t_mask  mask;
X    char   *np;
X
X    /* use `mask' to screen out most string comparisons */
X    mask = 0;
X    np = name;
X    while (*np)
X        mask += *np++;
X
X    /* see if we gotta return it */
X    if (maskp != NULL)
X        *maskp = mask;
X
X    /* linear search through file list */
X    for (filep = file_list; filep != NULL; filep = filep->fnext)
X    {
X        if (filep->fmask != mask)
X            continue;
X
X        if (equal(filep->fname, name))
X            return (filep);
X    }
X
X    /* nope, no file here */
X    return (NULL);
X}
X
X
X/*
X * append_node    - add a node to the end of an array of nodes
X */
Xchar  **append_node(node, adds, size)
Xchar  **node;
Xchar  **adds;
Xint     size;
X{
X    int     addlen, len;
X
X    for (addlen = 0; adds[addlen] != NULL; ++addlen);
X    if (addlen++ == 0)
X        return (node);
X
X    len = 0;
X
X    if (node != NULL)
X    {
X        for (; node[len] != NULL; ++len);
X        node = (char **) trealloc((char *) node, (len + addlen) * size);
X    }
X    else
X        node = (char **) talloc(addlen * size);
X
X    memcpy(node + len, adds, addlen * size);
X    return (node);
X}
X
X/*
X * add_shell    - create a new shell node, and add to end of given list
X */
Xshellptr add_shell(input)
Xchar   *input;
X{
X    shellptr snode;
X
X    snode = tnew(shellnode);/* allocate a new shell node */
X    snode->s_shell = snode->s_ignore = snode->s_silent = 0;
X
X    for (; isspace(*input); ++input);    /* skip over leading spaces */
X    for (;; ++input)
X    {
X        if (*input == '+')
X            snode->s_shell = 1;    /* must use command.com */
X        else
X        if (*input == '-')
X            snode->s_ignore = 1;    /* ignore return value */
X        else
X        if (*input == '@')
X            snode->s_silent = 1;    /* don't echo command */
X        else
X            break;
X    }
X
X    snode->scmd = tstrcpy(input);    /* allocate string and copy command */
X
X    snode->slink = shell_list;    /* attach to global list */
X    shell_list = snode;
X
X    return (snode);
X}
X
X
X/*
X * breakout    - replace macro names with values
X *        - apply recursively
X * note: allocates (and returns) a string which must be freed
X */
Xchar   *breakout(input)
Xchar   *input;
X{
X    char   *dest, *dend;
X    char   *dp;
X    int     dlen;
X    int     tlen;
X    int     state;
X    char    symname[100];
X    char   *sp;
X    symptr  symp;
X    int     slen;
X    char    endch;
X
X    /* allocate a string twice as long as input string */
X
X    dlen = strlen(input) * 2;
X    dest = dp = talloc(dlen);
X    dend = dest + dlen;
X
X/*
X *     state machine with 4 states
X *        0)    normal text    -- just copy
X *        1)    starting macro    -- define end char (e.g. ')', '}')
X *        2)    macro name    -- copy to a buffer
X *        3)    end of macro    -- look up value, and copy
X */
X    state = 0;
X
X    while (*input || state == 3)
X    {
X        /* if we don't have enough room, double size of string */
X        if (dp == dend)
X        {
X            dlen *= 2;
X            tlen = dp - dest;
X            dest = trealloc(dest, dlen);
X            dp = dest + tlen;
X            dend = dest + dlen;
X        }
X
X        switch (state)
X        {
X        case 0:
X            if (*input == '$')
X                state = 1;    /* found a macro */
X            else
X                *dp++ = *input++;
X            break;
X
X        case 1:
X            state = 2;    /* only in this state for 1 char */
X            sp = symname;
X            switch (*++input)
X            {
X            case '$':
X                *dp++ = '$';
X                state = 0;
X                break;
X            case '(':
X                endch = ')';
X                break;
X            case '{':
X                endch = '}';
X                break;
X            default:
X                /* single char; go to state 3 immediately */
X                *sp++ = *input;
X                state = 3;
X                break;
X            }
X            ++input;/* skip bracket (or character) */
X            break;
X
X        case 2:
X            if (*input == endch)
X                state = 3;
X            else
X                *sp++ = *input;
X
X            if ((sp - symname) >= (sizeof symname / sizeof symname[0]))
X            {
X                sp[-1] = '\0';
X                terror(1,
X                tstrcat("Macro too long (limit 100 chars): ",
X                    symname));
X            }
X
X            ++input;/* make sure we skip end char */
X            break;
X
X        case 3:
X            *sp = '\0';
X            symp = get_symbol(symname, 0);
X            sp = symp->svalue;
X            slen = -1;
X            while (sp && *sp)
X            {
X                /*
X                 * if value has a macro in it, we must
X                 * process recursively
X                 */
X                if (*sp == '$')
X                {
X                    sp = breakout(symp->svalue);
X                    /* now guaranteed not to have a '$' */
X                    slen = strlen(sp);
X                    break;
X                }
X                ++sp;
X            }
X
X            if (slen == -1)
X            {
X                /* value did NOT have a macro */
X                slen = (sp - symp->svalue);
X                sp = symp->svalue;
X            }
X
X            /* if we have not enough room, expand */
X            if (slen >= (dend - dp))
X            {
X                /* use slen to make sure that we can fit */
X                dlen = dlen * 2 + slen;
X                tlen = dp - dest;
X                dest = trealloc(dest, dlen);
X                dp = dest + tlen;
X                dend = dest + dlen;
X            }
X
X            /* if length is zero, don't bother to copy */
X            if (slen)
X            {
X                strcpy(dp, sp);
X                dp += slen;
X            }
X
X            if (sp != symp->svalue)
X                tfree(sp);    /* must've called `breakout' */
X
X            state = 0;    /* and we are back to text */
X            break;
X        }
X    }
X
X    if (state != 0)
X        terror(1, tstrcat("Improper macro.\n", dest));
X
X    *dp = '\0';        /* terminate the string */
X    return (dest);        /* and return it */
X}
END_OF_FILE
if test 17139 -ne `wc -c <'parse.c'`; then
    echo shar: \"'parse.c'\" unpacked with wrong size!
fi
# end of 'parse.c'
fi
if test -f 'tstring.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'tstring.c'\"
else
echo shar: Extracting \"'tstring.c'\" \(5480 characters\)
sed "s/^X//" >'tstring.c' <<'END_OF_FILE'
X/*
X * tstring.c
X *
X * 88-10-01 v1.0    created by greg yachuk, placed in the public domain
X * 88-10-06 v1.1    changed prerequisite list handling
X * 88-11-11 v1.2    fixed some bugs and added environment variables
X * 89-07-12 v1.3    stop appending shell commands, and flush output
X * 89-08-01 v1.4 AB    lots of new options and code
X * 89-10-30 v1.5    -f -S -q options, took some changes from v1.4
X * 90-04-18 v1.6    -b -- -W options, emulate <<, non-BSD cleanup
X */
X#include <stdio.h>
X#include <ctype.h>
X#include <malloc.h>
X#include <string.h>
X
X#include "tstring.h"
X
X
Xchar   *talloc(n)
Xint     n;
X{
X    char   *s;
X
X    s = malloc(n);
X    if (s == NULL)
X        terror(1, "no free memory");
X    return (s);
X}
X
X
Xchar   *trealloc(s, n)
Xchar   *s;
Xint     n;
X{
X    s = realloc(s, n);
X    if (s == NULL)
X        talloc(n);    /* force an error */
X    return (s);
X}
X
X
Xchar   *tstrncpy(s, n)
Xchar   *s;
Xint     n;
X{
X    s = strncpy(talloc(n + 1), s, n);
X    s[n] = '\0';
X    return (s);
X}
X
X
Xterror(n, s)
Xint     n;
Xchar   *s;
X{
X    fputs("Make: ", stderr);
X    fputs(s, stderr);
X    putc('\n', stderr);
X    if (n)
X        exit(n);
X}
X
X
X/*
X * tstrspan -    move to the end of a quoted string, ignoring escaped quotes
X */
Xchar   *tstrspan(str)
Xchar   *str;
X{
X    char    quote;
X
X    if (*str != '\'' && *str != '"')
X        return (str + 1);
X
X    quote = *str++;
X
X    while (*str && *str != quote)
X    {
X        /* check for escaped quote */
X        if (*str == '\\' && str[1] == quote)
X            ++str;
X        ++str;
X    }
X
X    return (str);
X}
X
X
X/*
X * tunquote -    remove quotes from a string
X */
Xchar   *tunquote(str)
Xchar   *str;
X{
X    char   *s;
X    char   *d;
X
X    d = s = str;
X
X    while (*s)
X    {
X        while (*s && *s == '"')
X            ++s;
X
X        while (*s && *s != '"')
X            *d++ = *s++;
X    }
X
X    *d = '\0';
X
X    return (str);
X}
X
X
X/*
X * tsplit -    split a string into two components, normally a directory
X *        path and a filename.  If a pointer to a directory is
X *        supplied, a string is allocated to contain the directory.
X *        The filename is returned as a pointer into the supplied
X *        string.
X */
Xchar   *tsplit(s, seps, dp)
Xchar   *s;
Xchar   *seps;
Xchar  **dp;
X{
X    char   *d;        /* directory portion */
X    char   *f;        /* file portion */
X
X    d = s;
X
X    /* find the final separator */
X    while ((f = strpbrk(d, seps)) != NULL)
X        d = f + 1;
X
X    /* back up to final component */
X    f = d;
X
X    /* if we are still at the beginning, there was no Directory */
X    if (d == s || dp == NULL)
X        d = NULL;
X    else
X    {
X        int     len;
X
X        /*
X         * by the time we get here, d points to the final separator
X         * char.  we can substitute a NULL for this sep-char.  Thus,
X         * we don't need to add 1 in the following length
X         * calculation.
X         */
X        len = d - s;
X
X        d = talloc(len);
X        d[--len] = '\0';
X        while (--len >= 0)
X            d[len] = s[len];
X    }
X
X    if (dp != NULL)
X        *dp = d;
X
X    return (f);
X}
X
X
X/*
X * token    - take an input string and return a token each call
X *        - default token delimiter characters are `isspace()'
X *        - separator chars are in addition to `isspace()'
X *        - text between quotes (" and ') is a single token
X *        - if requested, the separator char is returned
X *
X *    called as    s = token(string, seps, &schar);
X *        or    s = token(string, NULL, NULL);
X *
X *    followed by    s = token(NULL, seps, NULL);
X *        or    s = token(NULL, NULL, &schar);
X *
X *    returns NULL when no more tokens are available
X */
Xchar   *token(s, sep, schar)
Xchar   *s;
Xchar   *sep;
Xchar   *schar;
X{
X    static char *olds = NULL;
X
X    if (s)
X        olds = s;    /* we are starting all over again */
X
X    if (schar)
X        *schar = '\0';
X
X    if (!olds || !*olds)
X        return (NULL);    /* no tokens left */
X
X    while (isspace(*olds) || (sep && strchr(sep, *olds)))
X        ++olds;        /* skip leading spaces and sep's */
X
X    if (*olds == NULL)
X        return (NULL);    /* remainder is all separator's */
X
X    s = olds;
X
X    while (*olds)
X    {
X        if (isspace(*olds) || (sep && strchr(sep, *olds)))
X        {
X            if (schar)
X                *schar = *olds;
X            *olds++ = '\0';    /* delimit the token */
X            return (s);
X        }
X        else
X        if (*olds == '"' || *olds == '\'')
X        {
X            olds = tstrspan(olds);
X            if (*olds != '\0')
X                ++olds;    /* didn't hit eos, so skip quote */
X        }
X        else
X            ++olds;    /* otherwise, pass over char */
X    }
X
X    olds = NULL;
X    return (s);        /* return last token */
X}
X
X
X/*
X * tokenize    - chop a string up into an array of (char *)'s
X */
Xchar  **tokenize(input)
Xchar   *input;
X{
X    char  **argv;
X    int     argc = 0;
X    int     alen;
X
X    alen = 20;        /* good initial guess */
X    argv = (char **) talloc((alen + 1) * sizeof(char *));
X
X    input = token(input, NULL, NULL);    /* use default separators */
X    while (input)
X    {
X        if (alen == argc)
X            argv = (char **) trealloc((char *) argv,
X                         (alen <<= 1) * sizeof(char *));
X        argv[argc++] = input;
X        input = token(NULL, NULL, NULL);
X    }
X
X    argv[argc] = NULL;    /* mark end of array */
X
X    return (argv);
X}
X
X
X/*
X * tgets    - read input, swallowing escaped newlines as necessary
X */
Xchar   *tgets(fd)
XFILE   *fd;
X{
X    static char *input = NULL;
X    static int inlen = 0;
X    char   *ep;
X    int     len;
X
X    if (inlen == 0)
X        input = talloc(inlen = 162);
X
X    input[inlen - 2] = '\n';
X    ep = input - 1;
X    while ((fgets(input, inlen, fd)) != NULL)
X    {
X        for (;;)
X        {
X            while (input[inlen - 2] != '\n' && input[inlen - 2] != '\0')
X            {
X                len = inlen;
X                input = trealloc(input, inlen <<= 1);
X                ep = &input[len - 2];
X                input[inlen - 2] = '\n';
X                fgets(ep + 1, len + 1, fd);
X            }
X
X            while (*++ep);
X            *--ep = '\0';
X            do
X            {
X                --ep;
X            } while (ep >= input && isspace(*ep));
X
X            if (ep > input && *ep == '\\' && *--ep != '\\')
X                fgets(ep + 1, inlen - (ep - input) - 1, fd);
X            else
X                break;
X        }
X
X        return (input);
X    }
X
X    inlen = 0;
X    tfree(input);
X    input = NULL;
X
X    return (NULL);
X}
END_OF_FILE
if test 5480 -ne `wc -c <'tstring.c'`; then
    echo shar: \"'tstring.c'\" unpacked with wrong size!
fi
# end of 'tstring.c'
fi
if test -f 'tstring.h' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'tstring.h'\"
else
echo shar: Extracting \"'tstring.h'\" \(1310 characters\)
sed "s/^X//" >'tstring.h' <<'END_OF_FILE'
X/*
X * tstring.h
X *
X * 88-10-01 v1.0    created by greg yachuk, placed in the public domain
X * 88-10-06 v1.1    changed prerequisite list handling
X * 88-11-11 v1.2    fixed some bugs and added environment variables
X * 89-07-12 v1.3    stop appending shell commands, and flush output
X * 89-08-01 v1.4 AB    lots of new options and code
X * 89-10-30 v1.5    -f -S -q options, took some changes from v1.4
X * 90-04-18 v1.6    -b -- -W options, emulate <<, non-BSD cleanup
X */
X#define    tnew(t)        ((t *) talloc(sizeof(t)))
X#define    tfree(t)    (free((char *) t))
X
X#define    tstrcat(s,p)    (strcat(strcpy(talloc(strlen(s)+strlen(p)+1),(s)),(p)))
X#define    tstrcpy(s)    (strcpy(talloc(strlen(s)+1), (s)))
X
X#ifdef    __STDC__
Xextern char *talloc(int n);
Xextern char *trealloc(char *s, int n);
Xextern char *tstrncpy(char *s, int n);
Xextern int terror(int n, char *s);
Xextern char *tstrspan(char *str);
Xextern char *tunquote(char *str);
Xextern char *tsplit(char *s, char *seps, char **dp);
Xextern char *token(char *s, char *sep, char *schar);
Xextern char **tokenize(char *input);
Xextern char *tgets(FILE * fd);
X#else
Xextern char *talloc();
Xextern char *trealloc();
Xextern char *tstrncpy();
Xextern int terror();
Xextern char *tstrspan();
Xextern char *tunquote();
Xextern char *tsplit();
Xextern char *token();
Xextern char **tokenize();
Xextern char *tgets();
X#endif
END_OF_FILE
if test 1310 -ne `wc -c <'tstring.h'`; then
    echo shar: \"'tstring.h'\" unpacked with wrong size!
fi
# end of 'tstring.h'
fi
echo shar: End of archive 2 \(of 2\).
cp /dev/null ark2isdone
MISSING=""
for I in 1 2 ; do
    if test ! -f ark${I}isdone ; then
    MISSING="${MISSING} ${I}"
    fi
done
if test "${MISSING}" = "" ; then
    echo You have unpacked both archives.
    rm -f ark[1-9]isdone
else
    echo You still need to unpack the following archives:
    echo "        " ${MISSING}
fi
##  End of shell archive.
exit 0